#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
睡眠日志管理器使用示例

演示如何在睡眠监测系统中集成和使用SleepLogger

功能展示：
- 模拟完整的睡眠监测流程
- 展示各种类型数据的日志记录
- 演示会话管理和数据导出
"""

import time
import random
from sleep_logger import SleepLogger
from datetime import datetime


class MockSleepMonitor:
    """
    模拟睡眠监测器，演示日志记录的使用
    """
    
    def __init__(self):
        # 初始化日志管理器
        self.logger = SleepLogger(log_dir="../logs", file_prefix="sleep_monitor")
        self.is_monitoring = False
        self.session_id = None
    
    def start_monitoring(self, session_name=None):
        """
        开始监测会话
        """
        print("=== 开始睡眠监测 ===")
        
        # 创建新会话
        if session_name:
            self.session_id = self.logger.create_session_log(session_name)
        else:
            self.session_id = self.logger.create_session_log()
        
        print(f"会话ID: {self.session_id}")
        self.is_monitoring = True
        
        # 记录会话开始
        self.logger.system_logger.info(f"开始监测会话: {self.session_id}")
    
    def simulate_data_collection(self, duration_minutes=2):
        """
        模拟数据采集过程
        
        Args:
            duration_minutes: 模拟监测时长（分钟）
        """
        if not self.is_monitoring:
            print("请先开始监测")
            return
        
        print(f"模拟 {duration_minutes} 分钟的数据采集...")
        
        # 睡眠阶段序列（模拟真实的睡眠过程）
        sleep_stages = ['Wake', 'N1', 'N1', 'N2', 'N2', 'N3', 'N3', 'N2', 'REM', 'N2']
        
        total_iterations = int(duration_minutes * 6)  # 每10秒一次数据
        
        for i in range(total_iterations):
            # 模拟原始EEG数据
            raw_data = self._generate_mock_eeg_data()
            self.logger.log_raw_data(raw_data)
            
            # 每30秒进行一次数据处理和分析
            if i % 3 == 0:
                # 模拟数据预处理
                processed_data = self._generate_mock_processed_data()
                self.logger.log_processed_data(processed_data)
                
                # 模拟睡眠阶段分析
                stage_index = (i // 3) % len(sleep_stages)
                analysis_result = self._generate_mock_analysis_result(sleep_stages[stage_index])
                self.logger.log_analysis_result(analysis_result)
                
                print(f"时间: {i*10:3d}s - 阶段: {analysis_result['sleep_stage']} "
                      f"(置信度: {analysis_result['confidence']:.2f})")
            
            time.sleep(0.1)  # 加速模拟
        
        print("数据采集完成")
    
    def _generate_mock_eeg_data(self):
        """
        生成模拟的原始EEG数据
        """
        return {
            'eeg_value': random.randint(8000, 15000),
            'signal_quality': random.choice([0, 0, 0, 200]),  # 大部分时间信号良好
            'attention': random.randint(20, 80),
            'meditation': random.randint(15, 70)
        }
    
    def _generate_mock_processed_data(self):
        """
        生成模拟的预处理数据
        """
        # 模拟滤波后的EEG数据
        filtered_eeg = [random.uniform(-50, 50) for _ in range(20)]
        
        # 模拟频带功率
        frequency_bands = {
            'delta': random.uniform(0.1, 0.4),
            'theta': random.uniform(0.15, 0.35),
            'alpha': random.uniform(0.1, 0.3),
            'beta': random.uniform(0.05, 0.25),
            'gamma': random.uniform(0.02, 0.15)
        }
        
        return {
            'filtered_eeg': filtered_eeg,
            'frequency_bands': frequency_bands,
            'artifacts_removed': random.choice([True, False])
        }
    
    def _generate_mock_analysis_result(self, target_stage):
        """
        生成模拟的分析结果
        
        Args:
            target_stage: 目标睡眠阶段
        """
        # 模拟原始预测（可能不准确）
        all_stages = ['Wake', 'N1', 'N2', 'N3', 'REM']
        raw_stage = random.choice(all_stages)
        
        # 模拟置信度
        confidence = random.uniform(0.6, 0.95)
        
        return {
            'sleep_stage': target_stage,  # 平滑后的最终结果
            'confidence': confidence,
            'raw_stage': raw_stage,       # YASA原始预测
            'smoothed_stage': target_stage # 平滑处理后的结果
        }
    
    def stop_monitoring(self):
        """
        停止监测
        """
        if not self.is_monitoring:
            print("当前没有进行监测")
            return
        
        print("\n=== 停止监测 ===")
        
        # 获取会话摘要
        summary = self.logger.get_session_summary()
        print(f"会话摘要: {summary}")
        
        # 导出日志文件
        try:
            exported_files = self.logger.export_logs()
            print(f"导出文件: {len(exported_files)} 个")
            for file_path in exported_files:
                print(f"  - {file_path}")
        except Exception as e:
            print(f"导出失败: {e}")
        
        # 记录会话结束
        self.logger.system_logger.info(f"结束监测会话: {self.session_id}")
        
        self.is_monitoring = False
        self.session_id = None
    
    def close(self):
        """
        关闭监测器
        """
        if self.is_monitoring:
            self.stop_monitoring()
        
        self.logger.close()
        print("监测器已关闭")


def demo_basic_usage():
    """
    基本使用演示
    """
    print("=== 基本使用演示 ===")
    
    # 创建监测器
    monitor = MockSleepMonitor()
    
    try:
        # 开始监测
        monitor.start_monitoring("demo_session_001")
        
        # 模拟数据采集
        monitor.simulate_data_collection(duration_minutes=1)
        
        # 停止监测
        monitor.stop_monitoring()
        
    finally:
        # 确保资源清理
        monitor.close()


def demo_multiple_sessions():
    """
    多会话演示
    """
    print("\n=== 多会话演示 ===")
    
    monitor = MockSleepMonitor()
    
    try:
        # 进行多个短会话
        for i in range(1, 4):
            session_name = f"multi_demo_{i:02d}"
            print(f"\n--- 会话 {i} ---")
            
            monitor.start_monitoring(session_name)
            monitor.simulate_data_collection(duration_minutes=0.5)  # 30秒
            monitor.stop_monitoring()
            
            time.sleep(0.5)  # 会话间隔
    
    finally:
        monitor.close()


def demo_integration_example():
    """
    集成示例：展示如何在实际项目中使用
    """
    print("\n=== 集成示例 ===")
    
    # 直接使用SleepLogger
    logger = SleepLogger(log_dir="integration_logs", file_prefix="integration_test")
    
    try:
        # 创建会话
        session_id = logger.create_session_log()
        print(f"集成测试会话: {session_id}")
        
        # 模拟实际使用场景
        print("模拟实际数据流...")
        
        # 1. 设备连接和初始化
        logger.system_logger.info("设备连接成功")
        
        # 2. 数据采集循环
        for i in range(10):
            # 原始数据
            logger.log_raw_data({
                'eeg_value': 10000 + i * 50,
                'signal_quality': 0,
                'attention': 50 + i,
                'meditation': 40 + i * 2
            })
            
            # 每3次进行处理和分析
            if i % 3 == 0:
                logger.log_processed_data({
                    'filtered_eeg': list(range(i, i+10)),
                    'frequency_bands': {'delta': 0.2 + i*0.01},
                    'artifacts_removed': i % 2 == 0
                })
                
                logger.log_analysis_result({
                    'sleep_stage': ['Wake', 'N1', 'N2', 'N3'][i//3],
                    'confidence': 0.8 + i*0.02,
                    'raw_stage': 'Wake',
                    'smoothed_stage': ['Wake', 'N1', 'N2', 'N3'][i//3]
                })
        
        # 3. 会话结束
        logger.system_logger.info("数据采集完成")
        
        # 4. 导出和清理
        exported = logger.export_logs()
        print(f"导出文件: {exported}")
        
    finally:
        logger.close()


if __name__ == "__main__":
    print("睡眠日志管理器使用示例\n")
    
    try:
        # 运行所有演示
        demo_basic_usage()
        demo_multiple_sessions()
        demo_integration_example()
        
        print("\n所有演示完成！")
        print("\n生成的日志文件位置:")
        print("- ../logs/ (基本演示)")
        print("- integration_logs/ (集成示例)")
        
    except KeyboardInterrupt:
        print("\n用户中断")
    except Exception as e:
        print(f"\n演示过程中发生错误: {e}")
        import traceback
        traceback.print_exc()